/****************************************************************************
 * Copyright (c) 2008 Free Software Foundation, Inc.                        *
 *                                                                          *
 * Permission is hereby granted, free of charge, to any person obtaining a  *
 * copy of this software and associated documentation files (the            *
 * "Software"), to deal in the Software without restriction, including      *
 * without limitation the rights to use, copy, modify, merge, publish,      *
 * distribute, distribute with modifications, sublicense, and/or sell       *
 * copies of the Software, and to permit persons to whom the Software is    *
 * furnished to do so, subject to the following conditions:                 *
 *                                                                          *
 * The above copyright notice and this permission notice shall be included  *
 * in all copies or substantial portions of the Software.                   *
 *                                                                          *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
 *                                                                          *
 * Except as contained in this notice, the name(s) of the above copyright   *
 * holders shall not be used in advertising or otherwise to promote the     *
 * sale, use or other dealings in this Software without prior written       *
 * authorization.                                                           *
 ****************************************************************************/

/****************************************************************************
 *  Author: Thomas E. Dickey 2008                                           *
 ****************************************************************************/
/* LINTLIBRARY */

/* ./tty/hardscroll.c */

#include <curses.priv.h>

#undef _nc_oldnums
int	*_nc_oldnums;

#undef _nc_scroll_optimize
void	_nc_scroll_optimize(void)
		{ /* void */ }

#undef _nc_linedump
void	_nc_linedump(void)
		{ /* void */ }

/* ./tty/hashmap.c */

#include <term.h>

#undef _nc_hash_map
void	_nc_hash_map(void)
		{ /* void */ }

#undef _nc_make_oldhash
void	_nc_make_oldhash(
		int	i)
		{ /* void */ }

#undef _nc_scroll_oldhash
void	_nc_scroll_oldhash(
		int	n, 
		int	top, 
		int	bot)
		{ /* void */ }

/* ./base/lib_addch.c */

#include <ctype.h>

#undef _nc_render
chtype	_nc_render(
		WINDOW	*win, 
		chtype	ch)
		{ return(*(chtype *)0); }

#undef _nc_waddch_nosync
int	_nc_waddch_nosync(
		WINDOW	*win, 
		const chtype c)
		{ return(*(int *)0); }

#undef waddch
int	waddch(
		WINDOW	*win, 
		const chtype ch)
		{ return(*(int *)0); }

#undef wechochar
int	wechochar(
		WINDOW	*win, 
		const chtype ch)
		{ return(*(int *)0); }

/* ./base/lib_addstr.c */

#undef waddnstr
int	waddnstr(
		WINDOW	*win, 
		const char *astr, 
		int	n)
		{ return(*(int *)0); }

#undef waddchnstr
int	waddchnstr(
		WINDOW	*win, 
		const chtype *astr, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_beep.c */

#undef beep
int	beep(void)
		{ return(*(int *)0); }

/* ./base/lib_bkgd.c */

#undef wbkgdset
void	wbkgdset(
		WINDOW	*win, 
		chtype	ch)
		{ /* void */ }

#undef wbkgd
int	wbkgd(
		WINDOW	*win, 
		chtype	ch)
		{ return(*(int *)0); }

/* ./base/lib_box.c */

#undef wborder
int	wborder(
		WINDOW	*win, 
		chtype	ls, 
		chtype	rs, 
		chtype	ts, 
		chtype	bs, 
		chtype	tl, 
		chtype	tr, 
		chtype	bl, 
		chtype	br)
		{ return(*(int *)0); }

/* ./base/lib_chgat.c */

#undef wchgat
int	wchgat(
		WINDOW	*win, 
		int	n, 
		attr_t	attr, 
		short	color, 
		const void *opts)
		{ return(*(int *)0); }

/* ./base/lib_clear.c */

#undef wclear
int	wclear(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_clearok.c */

#undef clearok
int	clearok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/lib_clrbot.c */

#undef wclrtobot
int	wclrtobot(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_clreol.c */

#undef wclrtoeol
int	wclrtoeol(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_color.c */

#include <tic.h>

#undef _nc_COLOR_PAIRS
int	_nc_COLOR_PAIRS(void)
		{ return(*(int *)0); }

#undef _nc_COLORS
int	_nc_COLORS(void)
		{ return(*(int *)0); }

#undef _nc_reset_colors
NCURSES_BOOL _nc_reset_colors(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef start_color
int	start_color(void)
		{ return(*(int *)0); }

#undef init_pair
int	init_pair(
		short	pair, 
		short	f, 
		short	b)
		{ return(*(int *)0); }

#undef init_color
int	init_color(
		short	color, 
		short	r, 
		short	g, 
		short	b)
		{ return(*(int *)0); }

#undef can_change_color
NCURSES_BOOL can_change_color(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_colors
NCURSES_BOOL has_colors(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef color_content
int	color_content(
		short	color, 
		short	*r, 
		short	*g, 
		short	*b)
		{ return(*(int *)0); }

#undef pair_content
int	pair_content(
		short	pair, 
		short	*f, 
		short	*b)
		{ return(*(int *)0); }

#undef _nc_do_color
void	_nc_do_color(
		short	old_pair, 
		short	pair, 
		NCURSES_BOOL reverse, 
		int	(*outc)(
		int	p1))
		{ /* void */ }

/* ./base/lib_colorset.c */

#undef wcolor_set
int	wcolor_set(
		WINDOW	*win, 
		short	color_pair_number, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_delch.c */

#undef wdelch
int	wdelch(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_delwin.c */

#undef delwin
int	delwin(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_echo.c */

#undef echo
int	echo(void)
		{ return(*(int *)0); }

#undef noecho
int	noecho(void)
		{ return(*(int *)0); }

/* ./base/lib_endwin.c */

#undef endwin
int	endwin(void)
		{ return(*(int *)0); }

/* ./base/lib_erase.c */

#undef werase
int	werase(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_flash.c */

#undef flash
int	flash(void)
		{ return(*(int *)0); }

/* ./lib_gen.c */

#undef addch
int	addch(
		const chtype z)
		{ return(*(int *)0); }

#undef addchnstr
int	addchnstr(
		const chtype *a1, 
		int	z)
		{ return(*(int *)0); }

#undef addchstr
int	addchstr(
		const chtype *z)
		{ return(*(int *)0); }

#undef addnstr
int	addnstr(
		const char *a1, 
		int	z)
		{ return(*(int *)0); }

#undef addstr
int	addstr(
		const char *z)
		{ return(*(int *)0); }

#undef attroff
int	attroff(
		NCURSES_ATTR_T	z)
		{ return(*(int *)0); }

#undef attron
int	attron(
		NCURSES_ATTR_T	z)
		{ return(*(int *)0); }

#undef attrset
int	attrset(
		NCURSES_ATTR_T	z)
		{ return(*(int *)0); }

#undef attr_get
int	attr_get(
		attr_t	*a1, 
		short	*a2, 
		void	*z)
		{ return(*(int *)0); }

#undef attr_off
int	attr_off(
		attr_t	a1, 
		void	*z)
		{ return(*(int *)0); }

#undef attr_on
int	attr_on(
		attr_t	a1, 
		void	*z)
		{ return(*(int *)0); }

#undef attr_set
int	attr_set(
		attr_t	a1, 
		short	a2, 
		void	*z)
		{ return(*(int *)0); }

#undef bkgd
int	bkgd(
		chtype	z)
		{ return(*(int *)0); }

#undef bkgdset
void	bkgdset(
		chtype	z)
		{ /* void */ }

#undef border
int	border(
		chtype	a1, 
		chtype	a2, 
		chtype	a3, 
		chtype	a4, 
		chtype	a5, 
		chtype	a6, 
		chtype	a7, 
		chtype	z)
		{ return(*(int *)0); }

#undef box
int	box(
		WINDOW	*a1, 
		chtype	a2, 
		chtype	z)
		{ return(*(int *)0); }

#undef chgat
int	chgat(
		int	a1, 
		attr_t	a2, 
		short	a3, 
		const void *z)
		{ return(*(int *)0); }

#undef clear
int	clear(void)
		{ return(*(int *)0); }

#undef clrtobot
int	clrtobot(void)
		{ return(*(int *)0); }

#undef clrtoeol
int	clrtoeol(void)
		{ return(*(int *)0); }

#undef color_set
int	color_set(
		short	a1, 
		void	*z)
		{ return(*(int *)0); }

#undef COLOR_PAIR
int	COLOR_PAIR(
		int	z)
		{ return(*(int *)0); }

#undef delch
int	delch(void)
		{ return(*(int *)0); }

#undef deleteln
int	deleteln(void)
		{ return(*(int *)0); }

#undef echochar
int	echochar(
		const chtype z)
		{ return(*(int *)0); }

#undef erase
int	erase(void)
		{ return(*(int *)0); }

#undef getbkgd
chtype	getbkgd(
		WINDOW	*z)
		{ return(*(chtype *)0); }

#undef getch
int	getch(void)
		{ return(*(int *)0); }

#undef getnstr
int	getnstr(
		char	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef getstr
int	getstr(
		char	*z)
		{ return(*(int *)0); }

#undef hline
int	hline(
		chtype	a1, 
		int	z)
		{ return(*(int *)0); }

#undef inch
chtype	inch(void)
		{ return(*(chtype *)0); }

#undef inchnstr
int	inchnstr(
		chtype	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef inchstr
int	inchstr(
		chtype	*z)
		{ return(*(int *)0); }

#undef innstr
int	innstr(
		char	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef insch
int	insch(
		chtype	z)
		{ return(*(int *)0); }

#undef insdelln
int	insdelln(
		int	z)
		{ return(*(int *)0); }

#undef insertln
int	insertln(void)
		{ return(*(int *)0); }

#undef insnstr
int	insnstr(
		const char *a1, 
		int	z)
		{ return(*(int *)0); }

#undef insstr
int	insstr(
		const char *z)
		{ return(*(int *)0); }

#undef instr
int	instr(
		char	*z)
		{ return(*(int *)0); }

#undef move
int	move(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef mvaddch
int	mvaddch(
		int	a1, 
		int	a2, 
		const chtype z)
		{ return(*(int *)0); }

#undef mvaddchnstr
int	mvaddchnstr(
		int	a1, 
		int	a2, 
		const chtype *a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvaddchstr
int	mvaddchstr(
		int	a1, 
		int	a2, 
		const chtype *z)
		{ return(*(int *)0); }

#undef mvaddnstr
int	mvaddnstr(
		int	a1, 
		int	a2, 
		const char *a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvaddstr
int	mvaddstr(
		int	a1, 
		int	a2, 
		const char *z)
		{ return(*(int *)0); }

#undef mvchgat
int	mvchgat(
		int	a1, 
		int	a2, 
		int	a3, 
		attr_t	a4, 
		short	a5, 
		const void *z)
		{ return(*(int *)0); }

#undef mvdelch
int	mvdelch(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef mvgetch
int	mvgetch(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef mvgetnstr
int	mvgetnstr(
		int	a1, 
		int	a2, 
		char	*a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvgetstr
int	mvgetstr(
		int	a1, 
		int	a2, 
		char	*z)
		{ return(*(int *)0); }

#undef mvhline
int	mvhline(
		int	a1, 
		int	a2, 
		chtype	a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinch
chtype	mvinch(
		int	a1, 
		int	z)
		{ return(*(chtype *)0); }

#undef mvinchnstr
int	mvinchnstr(
		int	a1, 
		int	a2, 
		chtype	*a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinchstr
int	mvinchstr(
		int	a1, 
		int	a2, 
		chtype	*z)
		{ return(*(int *)0); }

#undef mvinnstr
int	mvinnstr(
		int	a1, 
		int	a2, 
		char	*a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinsch
int	mvinsch(
		int	a1, 
		int	a2, 
		chtype	z)
		{ return(*(int *)0); }

#undef mvinsnstr
int	mvinsnstr(
		int	a1, 
		int	a2, 
		const char *a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinsstr
int	mvinsstr(
		int	a1, 
		int	a2, 
		const char *z)
		{ return(*(int *)0); }

#undef mvinstr
int	mvinstr(
		int	a1, 
		int	a2, 
		char	*z)
		{ return(*(int *)0); }

#undef mvvline
int	mvvline(
		int	a1, 
		int	a2, 
		chtype	a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvwaddch
int	mvwaddch(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const chtype z)
		{ return(*(int *)0); }

#undef mvwaddchnstr
int	mvwaddchnstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const chtype *a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwaddchstr
int	mvwaddchstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const chtype *z)
		{ return(*(int *)0); }

#undef mvwaddnstr
int	mvwaddnstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwaddstr
int	mvwaddstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *z)
		{ return(*(int *)0); }

#undef mvwchgat
int	mvwchgat(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		int	a4, 
		attr_t	a5, 
		short	a6, 
		const void *z)
		{ return(*(int *)0); }

#undef mvwdelch
int	mvwdelch(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(int *)0); }

#undef mvwgetch
int	mvwgetch(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(int *)0); }

#undef mvwgetnstr
int	mvwgetnstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwgetstr
int	mvwgetstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*z)
		{ return(*(int *)0); }

#undef mvwhline
int	mvwhline(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinch
chtype	mvwinch(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(chtype *)0); }

#undef mvwinchnstr
int	mvwinchnstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	*a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinchstr
int	mvwinchstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	*z)
		{ return(*(int *)0); }

#undef mvwinnstr
int	mvwinnstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinsch
int	mvwinsch(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	z)
		{ return(*(int *)0); }

#undef mvwinsnstr
int	mvwinsnstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinsstr
int	mvwinsstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *z)
		{ return(*(int *)0); }

#undef mvwinstr
int	mvwinstr(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*z)
		{ return(*(int *)0); }

#undef mvwvline
int	mvwvline(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	a4, 
		int	z)
		{ return(*(int *)0); }

#undef PAIR_NUMBER
int	PAIR_NUMBER(
		int	z)
		{ return(*(int *)0); }

#undef redrawwin
int	redrawwin(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef refresh
int	refresh(void)
		{ return(*(int *)0); }

#undef scrl
int	scrl(
		int	z)
		{ return(*(int *)0); }

#undef scroll
int	scroll(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef setscrreg
int	setscrreg(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef standout
int	standout(void)
		{ return(*(int *)0); }

#undef standend
int	standend(void)
		{ return(*(int *)0); }

#undef timeout
void	timeout(
		int	z)
		{ /* void */ }

#undef touchline
int	touchline(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(int *)0); }

#undef touchwin
int	touchwin(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef untouchwin
int	untouchwin(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef vline
int	vline(
		chtype	a1, 
		int	z)
		{ return(*(int *)0); }

#undef vw_printw
int	vw_printw(
		WINDOW	*a1, 
		const char *a2, 
		va_list	z)
		{ return(*(int *)0); }

#undef vw_scanw
int	vw_scanw(
		WINDOW	*a1, 
		char	*a2, 
		va_list	z)
		{ return(*(int *)0); }

#undef waddchstr
int	waddchstr(
		WINDOW	*a1, 
		const chtype *z)
		{ return(*(int *)0); }

#undef waddstr
int	waddstr(
		WINDOW	*a1, 
		const char *z)
		{ return(*(int *)0); }

#undef wattron
int	wattron(
		WINDOW	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef wattroff
int	wattroff(
		WINDOW	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef wattrset
int	wattrset(
		WINDOW	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef wattr_get
int	wattr_get(
		WINDOW	*a1, 
		attr_t	*a2, 
		short	*a3, 
		void	*z)
		{ return(*(int *)0); }

#undef wattr_set
int	wattr_set(
		WINDOW	*a1, 
		attr_t	a2, 
		short	a3, 
		void	*z)
		{ return(*(int *)0); }

#undef wdeleteln
int	wdeleteln(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef wgetstr
int	wgetstr(
		WINDOW	*a1, 
		char	*z)
		{ return(*(int *)0); }

#undef winchstr
int	winchstr(
		WINDOW	*a1, 
		chtype	*z)
		{ return(*(int *)0); }

#undef winsertln
int	winsertln(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef winsstr
int	winsstr(
		WINDOW	*a1, 
		const char *z)
		{ return(*(int *)0); }

#undef winstr
int	winstr(
		WINDOW	*a1, 
		char	*z)
		{ return(*(int *)0); }

#undef wstandout
int	wstandout(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef wstandend
int	wstandend(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef getattrs
int	getattrs(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getcurx
int	getcurx(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getcury
int	getcury(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getbegx
int	getbegx(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getbegy
int	getbegy(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getmaxx
int	getmaxx(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getmaxy
int	getmaxy(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getparx
int	getparx(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getpary
int	getpary(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef wgetparent
WINDOW	*wgetparent(
		const WINDOW *z)
		{ return(*(WINDOW **)0); }

#undef is_cleared
NCURSES_BOOL is_cleared(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_idcok
NCURSES_BOOL is_idcok(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_idlok
NCURSES_BOOL is_idlok(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_immedok
NCURSES_BOOL is_immedok(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_keypad
NCURSES_BOOL is_keypad(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_leaveok
NCURSES_BOOL is_leaveok(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_nodelay
NCURSES_BOOL is_nodelay(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_notimeout
NCURSES_BOOL is_notimeout(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_scrollok
NCURSES_BOOL is_scrollok(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_syncok
NCURSES_BOOL is_syncok(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef wgetscrreg
int	wgetscrreg(
		const WINDOW *a1, 
		int	*a2, 
		int	*z)
		{ return(*(int *)0); }

#undef mouse_trafo
NCURSES_BOOL mouse_trafo(
		int	*a1, 
		int	*a2, 
		NCURSES_BOOL z)
		{ return(*(NCURSES_BOOL *)0); }

/* ./base/lib_getch.c */

#include <fifo_defs.h>

#undef _nc_ESCDELAY
int	_nc_ESCDELAY(void)
		{ return(*(int *)0); }

#undef set_escdelay
int	set_escdelay(
		int	value)
		{ return(*(int *)0); }

#undef _nc_wgetch
int	_nc_wgetch(
		WINDOW	*win, 
		unsigned long *result, 
		int	use_meta)
		{ return(*(int *)0); }

#undef wgetch
int	wgetch(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_getstr.c */

#undef wgetnstr
int	wgetnstr(
		WINDOW	*win, 
		char	*str, 
		int	maxlen)
		{ return(*(int *)0); }

/* ./base/lib_hline.c */

#undef whline
int	whline(
		WINDOW	*win, 
		chtype	ch, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_immedok.c */

#undef immedok
void	immedok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ /* void */ }

/* ./base/lib_inchstr.c */

#undef winchnstr
int	winchnstr(
		WINDOW	*win, 
		chtype	*str, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_initscr.c */

#undef initscr
WINDOW	*initscr(void)
		{ return(*(WINDOW **)0); }

/* ./base/lib_insch.c */

#undef _nc_insert_ch
int	_nc_insert_ch(
		WINDOW	*win, 
		chtype	ch)
		{ return(*(int *)0); }

#undef winsch
int	winsch(
		WINDOW	*win, 
		chtype	c)
		{ return(*(int *)0); }

/* ./base/lib_insdel.c */

#undef winsdelln
int	winsdelln(
		WINDOW	*win, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_insnstr.c */

#undef winsnstr
int	winsnstr(
		WINDOW	*win, 
		const char *s, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_instr.c */

#undef winnstr
int	winnstr(
		WINDOW	*win, 
		char	*str, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_isendwin.c */

#undef isendwin
NCURSES_BOOL isendwin(void)
		{ return(*(NCURSES_BOOL *)0); }

/* ./base/lib_leaveok.c */

#undef leaveok
int	leaveok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/lib_mouse.c */

#undef getmouse
int	getmouse(
		MEVENT	*aevent)
		{ return(*(int *)0); }

#undef ungetmouse
int	ungetmouse(
		MEVENT	*aevent)
		{ return(*(int *)0); }

#undef mousemask
mmask_t	mousemask(
		mmask_t	newmask, 
		mmask_t	*oldmask)
		{ return(*(mmask_t *)0); }

#undef wenclose
NCURSES_BOOL wenclose(
		const WINDOW *win, 
		int	y, 
		int	x)
		{ return(*(NCURSES_BOOL *)0); }

#undef mouseinterval
int	mouseinterval(
		int	maxclick)
		{ return(*(int *)0); }

#undef _nc_has_mouse
int	_nc_has_mouse(void)
		{ return(*(int *)0); }

#undef wmouse_trafo
NCURSES_BOOL wmouse_trafo(
		const WINDOW *win, 
		int	*pY, 
		int	*pX, 
		NCURSES_BOOL to_screen)
		{ return(*(NCURSES_BOOL *)0); }

/* ./base/lib_move.c */

#undef wmove
int	wmove(
		WINDOW	*win, 
		int	y, 
		int	x)
		{ return(*(int *)0); }

/* ./tty/lib_mvcur.c */

#undef _nc_msec_cost
int	_nc_msec_cost(
		const char *const cap, 
		int	affcnt)
		{ return(*(int *)0); }

#undef _nc_mvcur_resume
void	_nc_mvcur_resume(void)
		{ /* void */ }

#undef _nc_mvcur_init
void	_nc_mvcur_init(void)
		{ /* void */ }

#undef _nc_mvcur_wrap
void	_nc_mvcur_wrap(void)
		{ /* void */ }

#undef mvcur
int	mvcur(
		int	yold, 
		int	xold, 
		int	ynew, 
		int	xnew)
		{ return(*(int *)0); }

#undef _nc_optimize_enable
int	_nc_optimize_enable;

/* ./base/lib_mvwin.c */

#undef mvwin
int	mvwin(
		WINDOW	*win, 
		int	by, 
		int	bx)
		{ return(*(int *)0); }

/* ./base/lib_newterm.c */

#undef filter
void	filter(void)
		{ /* void */ }

#undef nofilter
void	nofilter(void)
		{ /* void */ }

#undef newterm
SCREEN	*newterm(
		char	*name, 
		FILE	*ofp, 
		FILE	*ifp)
		{ return(*(SCREEN **)0); }

/* ./base/lib_newwin.c */

#undef _nc_freewin
int	_nc_freewin(
		WINDOW	*win)
		{ return(*(int *)0); }

#undef newwin
WINDOW	*newwin(
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef derwin
WINDOW	*derwin(
		WINDOW	*orig, 
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef subwin
WINDOW	*subwin(
		WINDOW	*w, 
		int	l, 
		int	c, 
		int	y, 
		int	x)
		{ return(*(WINDOW **)0); }

#undef _nc_makenew
WINDOW	*_nc_makenew(
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx, 
		int	flags)
		{ return(*(WINDOW **)0); }

#undef _nc_screen_of
SCREEN	*_nc_screen_of(
		WINDOW	*win)
		{ return(*(SCREEN **)0); }

/* ./base/lib_nl.c */

#undef nl
int	nl(void)
		{ return(*(int *)0); }

#undef nonl
int	nonl(void)
		{ return(*(int *)0); }

/* ./base/lib_overlay.c */

#undef overlay
int	overlay(
		const WINDOW *win1, 
		WINDOW	*win2)
		{ return(*(int *)0); }

#undef overwrite
int	overwrite(
		const WINDOW *win1, 
		WINDOW	*win2)
		{ return(*(int *)0); }

#undef copywin
int	copywin(
		const WINDOW *src, 
		WINDOW	*dst, 
		int	sminrow, 
		int	smincol, 
		int	dminrow, 
		int	dmincol, 
		int	dmaxrow, 
		int	dmaxcol, 
		int	over)
		{ return(*(int *)0); }

/* ./base/lib_pad.c */

#undef newpad
WINDOW	*newpad(
		int	l, 
		int	c)
		{ return(*(WINDOW **)0); }

#undef subpad
WINDOW	*subpad(
		WINDOW	*orig, 
		int	l, 
		int	c, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef prefresh
int	prefresh(
		WINDOW	*win, 
		int	pminrow, 
		int	pmincol, 
		int	sminrow, 
		int	smincol, 
		int	smaxrow, 
		int	smaxcol)
		{ return(*(int *)0); }

#undef pnoutrefresh
int	pnoutrefresh(
		WINDOW	*win, 
		int	pminrow, 
		int	pmincol, 
		int	sminrow, 
		int	smincol, 
		int	smaxrow, 
		int	smaxcol)
		{ return(*(int *)0); }

#undef pechochar
int	pechochar(
		WINDOW	*pad, 
		const chtype ch)
		{ return(*(int *)0); }

/* ./base/lib_printw.c */

#undef printw
int	printw(
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef wprintw
int	wprintw(
		WINDOW	*win, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef mvprintw
int	mvprintw(
		int	y, 
		int	x, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef mvwprintw
int	mvwprintw(
		WINDOW	*win, 
		int	y, 
		int	x, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef vwprintw
int	vwprintw(
		WINDOW	*win, 
		const char *fmt, 
		va_list	argp)
		{ return(*(int *)0); }

/* ./base/lib_redrawln.c */

#undef wredrawln
int	wredrawln(
		WINDOW	*win, 
		int	beg, 
		int	num)
		{ return(*(int *)0); }

/* ./base/lib_refresh.c */

#undef wrefresh
int	wrefresh(
		WINDOW	*win)
		{ return(*(int *)0); }

#undef wnoutrefresh
int	wnoutrefresh(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_restart.c */

#undef restartterm
int	restartterm(
		char	*termp, 
		int	filenum, 
		int	*errret)
		{ return(*(int *)0); }

/* ./base/lib_scanw.c */

#undef vwscanw
int	vwscanw(
		WINDOW	*win, 
		char	*fmt, 
		va_list	argp)
		{ return(*(int *)0); }

#undef scanw
int	scanw(
		char	*fmt, 
		...)
		{ return(*(int *)0); }

#undef wscanw
int	wscanw(
		WINDOW	*win, 
		char	*fmt, 
		...)
		{ return(*(int *)0); }

#undef mvscanw
int	mvscanw(
		int	y, 
		int	x, 
		char	*fmt, 
		...)
		{ return(*(int *)0); }

#undef mvwscanw
int	mvwscanw(
		WINDOW	*win, 
		int	y, 
		int	x, 
		char	*fmt, 
		...)
		{ return(*(int *)0); }

/* ./base/lib_screen.c */

#undef getwin
WINDOW	*getwin(
		FILE	*filep)
		{ return(*(WINDOW **)0); }

#undef putwin
int	putwin(
		WINDOW	*win, 
		FILE	*filep)
		{ return(*(int *)0); }

#undef scr_restore
int	scr_restore(
		const char *file)
		{ return(*(int *)0); }

#undef scr_dump
int	scr_dump(
		const char *file)
		{ return(*(int *)0); }

#undef scr_init
int	scr_init(
		const char *file)
		{ return(*(int *)0); }

#undef scr_set
int	scr_set(
		const char *file)
		{ return(*(int *)0); }

/* ./base/lib_scroll.c */

#undef _nc_scroll_window
void	_nc_scroll_window(
		WINDOW	*win, 
		int const n, 
		int const top, 
		int const bottom, 
		chtype	blank)
		{ /* void */ }

#undef wscrl
int	wscrl(
		WINDOW	*win, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_scrollok.c */

#undef scrollok
int	scrollok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/lib_scrreg.c */

#undef wsetscrreg
int	wsetscrreg(
		WINDOW	*win, 
		int	top, 
		int	bottom)
		{ return(*(int *)0); }

/* ./base/lib_set_term.c */

#undef set_term
SCREEN	*set_term(
		SCREEN	*screenp)
		{ return(*(SCREEN **)0); }

#undef delscreen
void	delscreen(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_setupscreen
int	_nc_setupscreen(
		int	slines, 
		int	scolumns, 
		FILE	*output, 
		NCURSES_BOOL filtered, 
		int	slk_format)
		{ return(*(int *)0); }

#undef _nc_ripoffline
int	_nc_ripoffline(
		int	line, 
		int	(*init)(
		WINDOW	*p1, 
		int	p2))
		{ return(*(int *)0); }

#undef ripoffline
int	ripoffline(
		int	line, 
		int	(*init)(
		WINDOW	*p1, 
		int	p2))
		{ return(*(int *)0); }

/* ./base/lib_slk.c */

#undef _nc_slk_initialize
int	_nc_slk_initialize(
		WINDOW	*stwin, 
		int	cols)
		{ return(*(int *)0); }

#undef slk_restore
int	slk_restore(void)
		{ return(*(int *)0); }

/* ./base/lib_slkatr_set.c */

#undef slk_attr_set
int	slk_attr_set(
		const attr_t attr, 
		short	color_pair_number, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_slkatrof.c */

#undef slk_attroff
int	slk_attroff(
		const chtype attr)
		{ return(*(int *)0); }

/* ./base/lib_slkatron.c */

#undef slk_attron
int	slk_attron(
		const chtype attr)
		{ return(*(int *)0); }

/* ./base/lib_slkatrset.c */

#undef slk_attrset
int	slk_attrset(
		const chtype attr)
		{ return(*(int *)0); }

/* ./base/lib_slkattr.c */

#undef slk_attr
attr_t	slk_attr(void)
		{ return(*(attr_t *)0); }

/* ./base/lib_slkclear.c */

#undef slk_clear
int	slk_clear(void)
		{ return(*(int *)0); }

/* ./base/lib_slkcolor.c */

#undef slk_color
int	slk_color(
		short	color_pair_number)
		{ return(*(int *)0); }

/* ./base/lib_slkinit.c */

#undef slk_init
int	slk_init(
		int	format)
		{ return(*(int *)0); }

/* ./base/lib_slklab.c */

#undef slk_label
char	*slk_label(
		int	n)
		{ return(*(char **)0); }

/* ./base/lib_slkrefr.c */

#undef slk_noutrefresh
int	slk_noutrefresh(void)
		{ return(*(int *)0); }

#undef slk_refresh
int	slk_refresh(void)
		{ return(*(int *)0); }

/* ./base/lib_slkset.c */

#undef slk_set
int	slk_set(
		int	i, 
		const char *astr, 
		int	format)
		{ return(*(int *)0); }

/* ./base/lib_slktouch.c */

#undef slk_touch
int	slk_touch(void)
		{ return(*(int *)0); }

/* ./base/lib_touch.c */

#undef is_linetouched
NCURSES_BOOL is_linetouched(
		WINDOW	*win, 
		int	line)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_wintouched
NCURSES_BOOL is_wintouched(
		WINDOW	*win)
		{ return(*(NCURSES_BOOL *)0); }

#undef wtouchln
int	wtouchln(
		WINDOW	*win, 
		int	y, 
		int	n, 
		int	changed)
		{ return(*(int *)0); }

/* ./trace/lib_tracedmp.c */

#undef _tracedump
void	_tracedump(
		const char *name, 
		WINDOW	*win)
		{ /* void */ }

/* ./trace/lib_tracemse.c */

#undef _nc_tracemouse
char	*_nc_tracemouse(
		SCREEN	*sp, 
		MEVENT const *ep)
		{ return(*(char **)0); }

#undef _tracemouse
char	*_tracemouse(
		MEVENT const *ep)
		{ return(*(char **)0); }

/* ./tty/lib_tstp.c */

#include <SigAction.h>

#undef _nc_signal_handler
void	_nc_signal_handler(
		NCURSES_BOOL enable)
		{ /* void */ }

/* ./base/lib_ungetch.c */

#undef _nc_fifo_dump
void	_nc_fifo_dump(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_ungetch
int	_nc_ungetch(
		SCREEN	*sp, 
		int	ch)
		{ return(*(int *)0); }

#undef ungetch
int	ungetch(
		int	ch)
		{ return(*(int *)0); }

/* ./tty/lib_vidattr.c */

#undef vidputs
int	vidputs(
		chtype	newmode, 
		int	(*outc)(
		int	p1))
		{ return(*(int *)0); }

#undef vidattr
int	vidattr(
		chtype	newmode)
		{ return(*(int *)0); }

#undef termattrs
chtype	termattrs(void)
		{ return(*(chtype *)0); }

/* ./base/lib_vline.c */

#undef wvline
int	wvline(
		WINDOW	*win, 
		chtype	ch, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_wattroff.c */

#undef wattr_off
int	wattr_off(
		WINDOW	*win, 
		attr_t	at, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_wattron.c */

#undef wattr_on
int	wattr_on(
		WINDOW	*win, 
		attr_t	at, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_winch.c */

#undef winch
chtype	winch(
		WINDOW	*win)
		{ return(*(chtype *)0); }

/* ./base/lib_window.c */

#undef _nc_synchook
void	_nc_synchook(
		WINDOW	*win)
		{ /* void */ }

#undef mvderwin
int	mvderwin(
		WINDOW	*win, 
		int	y, 
		int	x)
		{ return(*(int *)0); }

#undef syncok
int	syncok(
		WINDOW	*win, 
		NCURSES_BOOL bf)
		{ return(*(int *)0); }

#undef wsyncup
void	wsyncup(
		WINDOW	*win)
		{ /* void */ }

#undef wsyncdown
void	wsyncdown(
		WINDOW	*win)
		{ /* void */ }

#undef wcursyncup
void	wcursyncup(
		WINDOW	*win)
		{ /* void */ }

#undef dupwin
WINDOW	*dupwin(
		WINDOW	*win)
		{ return(*(WINDOW **)0); }

/* ./base/nc_panel.c */

#undef _nc_panelhook
struct panelhook *_nc_panelhook(void)
		{ return(*(struct panelhook **)0); }

/* ./base/safe_sprintf.c */

#undef _nc_printf_string
char	*_nc_printf_string(
		const char *fmt, 
		va_list	ap)
		{ return(*(char **)0); }

/* ./tty/tty_update.c */

#include <sys/time.h>
#include <sys/times.h>

#undef doupdate
int	doupdate(void)
		{ return(*(int *)0); }

#undef _nc_scrolln
int	_nc_scrolln(
		int	n, 
		int	top, 
		int	bot, 
		int	maxy)
		{ return(*(int *)0); }

#undef _nc_screen_resume
void	_nc_screen_resume(void)
		{ /* void */ }

#undef _nc_screen_init
void	_nc_screen_init(void)
		{ /* void */ }

#undef _nc_screen_wrap
void	_nc_screen_wrap(void)
		{ /* void */ }

#undef _nc_do_xmc_glitch
void	_nc_do_xmc_glitch(
		attr_t	previous)
		{ /* void */ }

/* ./trace/varargs.c */

typedef enum {
    atUnknown = 0, atInteger, atFloat, atPoint, atString
} ARGTYPE;

#undef _nc_varargs
char	*_nc_varargs(
		const char *fmt, 
		va_list	ap)
		{ return(*(char **)0); }

/* ./base/memmove.c */

#undef _nc_memmove
void	_nc_memmove(void)
		{ /* void */ }

/* ./base/vsscanf.c */

#undef _nc_vsscanf
void	_nc_vsscanf(void)
		{ /* void */ }

/* ./base/lib_freeall.c */

#include <term_entry.h>

#undef _nc_freeall
void	_nc_freeall(void)
		{ /* void */ }

#undef _nc_free_and_exit
void	_nc_free_and_exit(
		int	code)
		{ /* void */ }

/* ./expanded.c */

#undef _nc_toggle_attr_on
void	_nc_toggle_attr_on(
		attr_t	*S, 
		attr_t	at)
		{ /* void */ }

#undef _nc_toggle_attr_off
void	_nc_toggle_attr_off(
		attr_t	*S, 
		attr_t	at)
		{ /* void */ }

#undef _nc_DelCharCost
int	_nc_DelCharCost(
		int	count)
		{ return(*(int *)0); }

#undef _nc_InsCharCost
int	_nc_InsCharCost(
		int	count)
		{ return(*(int *)0); }

#undef _nc_UpdateAttrs
void	_nc_UpdateAttrs(
		chtype	c)
		{ /* void */ }

/* ./base/legacy_coding.c */

#undef use_legacy_coding
int	use_legacy_coding(
		int	level)
		{ return(*(int *)0); }

/* ./base/lib_dft_fgbg.c */

#undef use_default_colors
int	use_default_colors(void)
		{ return(*(int *)0); }

#undef assume_default_colors
int	assume_default_colors(
		int	fg, 
		int	bg)
		{ return(*(int *)0); }

/* ./tinfo/lib_print.c */

#undef mcprint
int	mcprint(
		char	*data, 
		int	len)
		{ return(*(int *)0); }

/* ./base/resizeterm.c */

#undef is_term_resized
NCURSES_BOOL is_term_resized(
		int	ToLines, 
		int	ToCols)
		{ return(*(NCURSES_BOOL *)0); }

#undef resize_term
int	resize_term(
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

#undef resizeterm
int	resizeterm(
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

/* ./trace/trace_xnames.c */

#undef _nc_trace_xnames
void	_nc_trace_xnames(
		TERMTYPE *tp)
		{ /* void */ }

/* ./tinfo/use_screen.c */

#undef use_screen
int	use_screen(
		SCREEN	*screen, 
		NCURSES_SCREEN_CB func, 
		void	*data)
		{ return(*(int *)0); }

/* ./base/use_window.c */

#undef use_window
int	use_window(
		WINDOW	*win, 
		NCURSES_WINDOW_CB func, 
		void	*data)
		{ return(*(int *)0); }

/* ./base/wresize.c */

#undef wresize
int	wresize(
		WINDOW	*win, 
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

/* ./tinfo/access.c */

#include <sys/stat.h>
#include <nc_alloc.h>

#undef _nc_rootname
char	*_nc_rootname(
		char	*path)
		{ return(*(char **)0); }

#undef _nc_is_abs_path
NCURSES_BOOL _nc_is_abs_path(
		const char *path)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_pathlast
unsigned _nc_pathlast(
		const char *path)
		{ return(*(unsigned *)0); }

#undef _nc_basename
char	*_nc_basename(
		char	*path)
		{ return(*(char **)0); }

#undef _nc_access
int	_nc_access(
		const char *path, 
		int	mode)
		{ return(*(int *)0); }

#undef _nc_is_dir_path
NCURSES_BOOL _nc_is_dir_path(
		const char *path)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_is_file_path
NCURSES_BOOL _nc_is_file_path(
		const char *path)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_env_access
int	_nc_env_access(void)
		{ return(*(int *)0); }

/* ./tinfo/add_tries.c */

#undef _nc_add_to_try
int	_nc_add_to_try(
		TRIES	**tree, 
		const char *str, 
		unsigned code)
		{ return(*(int *)0); }

/* ./tinfo/alloc_ttype.c */

#undef _nc_align_termtype
void	_nc_align_termtype(
		TERMTYPE *to, 
		TERMTYPE *from)
		{ /* void */ }

#undef _nc_copy_termtype
void	_nc_copy_termtype(
		TERMTYPE *dst, 
		TERMTYPE *src)
		{ /* void */ }

/* ./codes.c */

#undef _nc_boolcodes
char	*const *_nc_boolcodes(void)
		{ return(*(char **)0); }

#undef _nc_numcodes
char	*const *_nc_numcodes(void)
		{ return(*(char **)0); }

#undef _nc_strcodes
char	*const *_nc_strcodes(void)
		{ return(*(char **)0); }

/* ./tinfo/comp_error.c */

#undef _nc_suppress_warnings
NCURSES_BOOL _nc_suppress_warnings;
#undef _nc_curr_line
int	_nc_curr_line;
#undef _nc_curr_col
int	_nc_curr_col;

#undef _nc_get_source
const char *_nc_get_source(void)
		{ return(*(const char **)0); }

#undef _nc_set_source
void	_nc_set_source(
		const char *const name)
		{ /* void */ }

#undef _nc_set_type
void	_nc_set_type(
		const char *const name)
		{ /* void */ }

#undef _nc_get_type
void	_nc_get_type(
		char	*name)
		{ /* void */ }

#undef _nc_warning
void	_nc_warning(
		const char *const fmt, 
		...)
		{ /* void */ }

#undef _nc_err_abort
void	_nc_err_abort(
		const char *const fmt, 
		...)
		{ /* void */ }

#undef _nc_syserr_abort
void	_nc_syserr_abort(
		const char *const fmt, 
		...)
		{ /* void */ }

/* ./tinfo/db_iterator.c */

#undef _nc_tic_dir
const char *_nc_tic_dir(
		const char *path)
		{ return(*(const char **)0); }

#undef _nc_keep_tic_dir
void	_nc_keep_tic_dir(
		const char *path)
		{ /* void */ }

#undef _nc_last_db
void	_nc_last_db(void)
		{ /* void */ }

#undef _nc_next_db
const char *_nc_next_db(
		DBDIRS	*state, 
		int	*offset)
		{ return(*(const char **)0); }

#undef _nc_first_db
void	_nc_first_db(
		DBDIRS	*state, 
		int	*offset)
		{ /* void */ }

/* ./tinfo/doalloc.c */

#undef _nc_doalloc
void	*_nc_doalloc(
		void	*oldp, 
		size_t	amount)
		{ return(*(void **)0); }

/* ./tinfo/entries.c */

#undef _nc_head
ENTRY	*_nc_head;
#undef _nc_tail
ENTRY	*_nc_tail;

#undef _nc_free_entry
void	_nc_free_entry(
		ENTRY	*headp, 
		TERMTYPE *tterm)
		{ /* void */ }

#undef _nc_free_entries
void	_nc_free_entries(
		ENTRY	*headp)
		{ /* void */ }

#undef _nc_delink_entry
ENTRY	*_nc_delink_entry(
		ENTRY	*headp, 
		TERMTYPE *tterm)
		{ return(*(ENTRY **)0); }

#undef _nc_leaks_tinfo
void	_nc_leaks_tinfo(void)
		{ /* void */ }

/* ./fallback.c */

#undef _nc_fallback
const TERMTYPE *_nc_fallback(
		const char *name)
		{ return(*(const TERMTYPE **)0); }

/* ./tinfo/free_ttype.c */

#undef _nc_free_termtype
void	_nc_free_termtype(
		TERMTYPE *ptr)
		{ /* void */ }

#undef _nc_user_definable
NCURSES_BOOL _nc_user_definable;

#undef use_extended_names
int	use_extended_names(
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./tinfo/getenv_num.c */

#undef _nc_getenv_num
int	_nc_getenv_num(
		const char *name)
		{ return(*(int *)0); }

/* ./tinfo/home_terminfo.c */

#undef _nc_home_terminfo
char	*_nc_home_terminfo(void)
		{ return(*(char **)0); }

/* ./tinfo/init_keytry.c */

#if 0

#include <init_keytry.h>

#undef _nc_tinfo_fkeys
const struct tinfo_fkeys _nc_tinfo_fkeys[] = {0};

#endif

#undef _nc_init_keytry
void	_nc_init_keytry(
		SCREEN	*sp)
		{ /* void */ }

/* ./tinfo/lib_acs.c */

#undef _nc_acs_map
chtype	*_nc_acs_map(void)
		{ return(*(chtype **)0); }

#undef _nc_init_acs
void	_nc_init_acs(void)
		{ /* void */ }

/* ./tinfo/lib_baudrate.c */

#include <termcap.h>

struct speed {
    int s; 
    int sp; 
};

#undef _nc_baudrate
int	_nc_baudrate(
		int	OSpeed)
		{ return(*(int *)0); }

#undef _nc_ospeed
int	_nc_ospeed(
		int	BaudRate)
		{ return(*(int *)0); }

#undef baudrate
int	baudrate(void)
		{ return(*(int *)0); }

/* ./tinfo/lib_cur_term.c */

#undef _nc_cur_term
TERMINAL *_nc_cur_term(void)
		{ return(*(TERMINAL **)0); }

#undef set_curterm
TERMINAL *set_curterm(
		TERMINAL *termp)
		{ return(*(TERMINAL **)0); }

#undef del_curterm
int	del_curterm(
		TERMINAL *termp)
		{ return(*(int *)0); }

/* ./tinfo/lib_data.c */

#undef _nc_stdscr
WINDOW	*_nc_stdscr(void)
		{ return(*(WINDOW **)0); }

#undef _nc_curscr
WINDOW	*_nc_curscr(void)
		{ return(*(WINDOW **)0); }

#undef _nc_newscr
WINDOW	*_nc_newscr(void)
		{ return(*(WINDOW **)0); }

#undef _nc_screen_chain
SCREEN	*_nc_screen_chain;
#undef SP
SCREEN	*SP;
#undef _nc_globals
NCURSES_GLOBALS _nc_globals;
#undef _nc_prescreen
NCURSES_PRESCREEN _nc_prescreen;

#undef _nc_init_pthreads
void	_nc_init_pthreads(void)
		{ /* void */ }

#undef _nc_mutex_init
void	_nc_mutex_init(
		pthread_mutex_t *obj)
		{ /* void */ }

#undef _nc_mutex_lock
int	_nc_mutex_lock(
		pthread_mutex_t *obj)
		{ return(*(int *)0); }

#undef _nc_mutex_trylock
int	_nc_mutex_trylock(
		pthread_mutex_t *obj)
		{ return(*(int *)0); }

#undef _nc_mutex_unlock
int	_nc_mutex_unlock(
		pthread_mutex_t *obj)
		{ return(*(int *)0); }

/* ./tinfo/lib_has_cap.c */

#undef has_ic
NCURSES_BOOL has_ic(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_il
NCURSES_BOOL has_il(void)
		{ return(*(NCURSES_BOOL *)0); }

/* ./tinfo/lib_kernel.c */

#undef erasechar
char	erasechar(void)
		{ return(*(char *)0); }

#undef killchar
char	killchar(void)
		{ return(*(char *)0); }

#undef flushinp
int	flushinp(void)
		{ return(*(int *)0); }

/* ./lib_keyname.c */

struct kn { short offset; int code; };

#undef _nc_keyname
char	*_nc_keyname(
		SCREEN	*sp, 
		int	c)
		{ return(*(char **)0); }

#undef keyname
char	*keyname(
		int	c)
		{ return(*(char **)0); }

/* ./tinfo/lib_longname.c */

#undef longname
char	*longname(void)
		{ return(*(char **)0); }

/* ./tinfo/lib_napms.c */

#undef napms
int	napms(
		int	ms)
		{ return(*(int *)0); }

/* ./tinfo/lib_options.c */

#undef idlok
int	idlok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef idcok
void	idcok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ /* void */ }

#undef halfdelay
int	halfdelay(
		int	t)
		{ return(*(int *)0); }

#undef nodelay
int	nodelay(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef notimeout
int	notimeout(
		WINDOW	*win, 
		NCURSES_BOOL f)
		{ return(*(int *)0); }

#undef wtimeout
void	wtimeout(
		WINDOW	*win, 
		int	delay)
		{ /* void */ }

#undef keypad
int	keypad(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef meta
int	meta(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef curs_set
int	curs_set(
		int	vis)
		{ return(*(int *)0); }

#undef typeahead
int	typeahead(
		int	fd)
		{ return(*(int *)0); }

#undef has_key
int	has_key(
		int	keycode)
		{ return(*(int *)0); }

#undef _nc_keypad
int	_nc_keypad(
		SCREEN	*sp, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./tinfo/lib_raw.c */

#undef raw
int	raw(void)
		{ return(*(int *)0); }

#undef cbreak
int	cbreak(void)
		{ return(*(int *)0); }

#undef qiflush
void	qiflush(void)
		{ /* void */ }

#undef noraw
int	noraw(void)
		{ return(*(int *)0); }

#undef nocbreak
int	nocbreak(void)
		{ return(*(int *)0); }

#undef noqiflush
void	noqiflush(void)
		{ /* void */ }

#undef intrflush
int	intrflush(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./tinfo/lib_setup.c */

#include <locale.h>
#include <sys/ioctl.h>
#include <langinfo.h>

#undef _nc_ttytype
char	*_nc_ttytype(void)
		{ return(*(char **)0); }

#undef _nc_ptr_Lines
int	*_nc_ptr_Lines(void)
		{ return(*(int **)0); }

#undef _nc_LINES
int	_nc_LINES(void)
		{ return(*(int *)0); }

#undef _nc_ptr_Cols
int	*_nc_ptr_Cols(void)
		{ return(*(int **)0); }

#undef _nc_COLS
int	_nc_COLS(void)
		{ return(*(int *)0); }

#undef _nc_TABSIZE
int	_nc_TABSIZE(void)
		{ return(*(int *)0); }

#undef set_tabsize
int	set_tabsize(
		int	value)
		{ return(*(int *)0); }

#undef _nc_handle_sigwinch
int	_nc_handle_sigwinch(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef use_env
void	use_env(
		NCURSES_BOOL f)
		{ /* void */ }

#undef _nc_get_screensize
void	_nc_get_screensize(
		SCREEN	*sp, 
		int	*linep, 
		int	*colp)
		{ /* void */ }

#undef _nc_update_screensize
void	_nc_update_screensize(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_get_locale
char	*_nc_get_locale(void)
		{ return(*(char **)0); }

#undef _nc_unicode_locale
int	_nc_unicode_locale(void)
		{ return(*(int *)0); }

#undef _nc_locale_breaks_acs
int	_nc_locale_breaks_acs(
		TERMINAL *termp)
		{ return(*(int *)0); }

#undef _nc_setupterm
int	_nc_setupterm(
		char	*tname, 
		int	Filedes, 
		int	*errret, 
		NCURSES_BOOL reuse)
		{ return(*(int *)0); }

#undef setupterm
int	setupterm(
		char	*tname, 
		int	Filedes, 
		int	*errret)
		{ return(*(int *)0); }

/* ./tinfo/lib_termcap.c */

#undef UP
char	*UP;
#undef BC
char	*BC;

#undef tgetent
int	tgetent(
		char	*bufp, 
		const char *name)
		{ return(*(int *)0); }

#if 0

#include <capdefaults.c>

#endif

#undef tgetflag
int	tgetflag(
		char	*id)
		{ return(*(int *)0); }

#undef tgetnum
int	tgetnum(
		char	*id)
		{ return(*(int *)0); }

#undef tgetstr
char	*tgetstr(
		char	*id, 
		char	**area)
		{ return(*(char **)0); }

/* ./tinfo/lib_termname.c */

#undef termname
char	*termname(void)
		{ return(*(char **)0); }

/* ./tinfo/lib_tgoto.c */

#undef tgoto
char	*tgoto(
		const char *string, 
		int	x, 
		int	y)
		{ return(*(char **)0); }

/* ./tinfo/lib_ti.c */

#undef tigetflag
int	tigetflag(
		char	*str)
		{ return(*(int *)0); }

#undef tigetnum
int	tigetnum(
		char	*str)
		{ return(*(int *)0); }

#undef tigetstr
char	*tigetstr(
		char	*str)
		{ return(*(char **)0); }

/* ./tinfo/lib_tparm.c */

#undef _nc_tparm_err
int	_nc_tparm_err;

#undef _nc_tparm_analyze
int	_nc_tparm_analyze(
		const char *string, 
		char	*p_is_s[9], 
		int	*popcount)
		{ return(*(int *)0); }

#undef tparm
char	*tparm(
		char	*string, 
		...)
		{ return(*(char **)0); }

/* ./tinfo/lib_tputs.c */

#undef PC
char	PC;
#undef ospeed
NCURSES_OSPEED	ospeed;
#undef _nc_nulls_sent
int	_nc_nulls_sent;

#undef _nc_set_no_padding
void	_nc_set_no_padding(
		SCREEN	*sp)
		{ /* void */ }

#undef delay_output
int	delay_output(
		int	ms)
		{ return(*(int *)0); }

#undef _nc_flush
void	_nc_flush(void)
		{ /* void */ }

#undef _nc_outch
int	_nc_outch(
		int	ch)
		{ return(*(int *)0); }

#undef putp
int	putp(
		const char *string)
		{ return(*(int *)0); }

#undef tputs
int	tputs(
		const char *string, 
		int	affcnt, 
		int	(*outc)(
		int	p1))
		{ return(*(int *)0); }

/* ./trace/lib_trace.c */

#undef _nc_tracing
unsigned _nc_tracing;

#undef _nc__nc_tputs_trace
const char *_nc__nc_tputs_trace(void)
		{ return(*(const char **)0); }

#undef _nc__nc_outchars
long	_nc__nc_outchars(void)
		{ return(*(long *)0); }

#undef _nc_set_tputs_trace
void	_nc_set_tputs_trace(
		const char *s)
		{ /* void */ }

#undef _nc_count_outchars
void	_nc_count_outchars(
		long	increment)
		{ /* void */ }

#undef trace
void	trace(
		const unsigned int tracelevel)
		{ /* void */ }

#undef _tracef
void	_tracef(
		const char *fmt, 
		...)
		{ /* void */ }

#undef _nc_retrace_bool
NCURSES_BOOL _nc_retrace_bool(
		NCURSES_BOOL code)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_retrace_int
int	_nc_retrace_int(
		int	code)
		{ return(*(int *)0); }

#undef _nc_retrace_unsigned
unsigned _nc_retrace_unsigned(
		unsigned code)
		{ return(*(unsigned *)0); }

#undef _nc_retrace_ptr
char	*_nc_retrace_ptr(
		char	*code)
		{ return(*(char **)0); }

#undef _nc_retrace_cptr
const char *_nc_retrace_cptr(
		const char *code)
		{ return(*(const char **)0); }

#undef _nc_retrace_cvoid_ptr
void	*_nc_retrace_cvoid_ptr(
		void	*code)
		{ return(*(void **)0); }

#undef _nc_retrace_void_ptr
void	*_nc_retrace_void_ptr(
		void	*code)
		{ return(*(void **)0); }

#undef _nc_retrace_sp
SCREEN	*_nc_retrace_sp(
		SCREEN	*code)
		{ return(*(SCREEN **)0); }

#undef _nc_retrace_win
WINDOW	*_nc_retrace_win(
		WINDOW	*code)
		{ return(*(WINDOW **)0); }

#undef _nc_use_tracef
int	_nc_use_tracef(
		unsigned mask)
		{ return(*(int *)0); }

#undef _nc_locked_tracef
void	_nc_locked_tracef(
		const char *fmt, 
		...)
		{ /* void */ }

/* ./trace/lib_traceatr.c */

#undef _traceattr2
char	*_traceattr2(
		int	bufnum, 
		chtype	newmode)
		{ return(*(char **)0); }

#undef _traceattr
char	*_traceattr(
		attr_t	newmode)
		{ return(*(char **)0); }

#undef _nc_retrace_attr_t
attr_t	_nc_retrace_attr_t(
		attr_t	code)
		{ return(*(attr_t *)0); }

#undef _nc_altcharset_name
const char *_nc_altcharset_name(
		attr_t	attr, 
		chtype	ch)
		{ return(*(const char **)0); }

#undef _tracechtype2
char	*_tracechtype2(
		int	bufnum, 
		chtype	ch)
		{ return(*(char **)0); }

#undef _tracechtype
char	*_tracechtype(
		chtype	ch)
		{ return(*(char **)0); }

#undef _nc_retrace_chtype
chtype	_nc_retrace_chtype(
		chtype	code)
		{ return(*(chtype *)0); }

/* ./trace/lib_tracebits.c */

typedef struct {
    unsigned int val;
    const char *name;
} BITNAMES;

#undef _nc_trace_ttymode
char	*_nc_trace_ttymode(
		struct termios *tty)
		{ return(*(char **)0); }

#undef _nc_tracebits
char	*_nc_tracebits(void)
		{ return(*(char **)0); }

/* ./trace/lib_tracechr.c */

#undef _nc_tracechar
char	*_nc_tracechar(
		SCREEN	*sp, 
		int	ch)
		{ return(*(char **)0); }

#undef _tracechar
char	*_tracechar(
		int	ch)
		{ return(*(char **)0); }

/* ./tinfo/lib_ttyflags.c */

#undef _nc_get_tty_mode
int	_nc_get_tty_mode(
		struct termios *buf)
		{ return(*(int *)0); }

#undef _nc_set_tty_mode
int	_nc_set_tty_mode(
		struct termios *buf)
		{ return(*(int *)0); }

#undef def_shell_mode
int	def_shell_mode(void)
		{ return(*(int *)0); }

#undef def_prog_mode
int	def_prog_mode(void)
		{ return(*(int *)0); }

#undef reset_prog_mode
int	reset_prog_mode(void)
		{ return(*(int *)0); }

#undef reset_shell_mode
int	reset_shell_mode(void)
		{ return(*(int *)0); }

#undef savetty
int	savetty(void)
		{ return(*(int *)0); }

#undef resetty
int	resetty(void)
		{ return(*(int *)0); }

/* ./tty/lib_twait.c */

#undef _nc_timed_wait
int	_nc_timed_wait(
		SCREEN	*sp, 
		int	mode, 
		int	milliseconds, 
		int	*timeleft)
		{ return(*(int *)0); }

/* ./tinfo/name_match.c */

#undef _nc_first_name
char	*_nc_first_name(
		const char *const sp)
		{ return(*(char **)0); }

#undef _nc_name_match
int	_nc_name_match(
		const char *const namelst, 
		const char *const name, 
		const char *const delim)
		{ return(*(int *)0); }

/* ./names.c */

#undef _nc_boolnames
char	*const *_nc_boolnames(void)
		{ return(*(char **)0); }

#undef _nc_boolfnames
char	*const *_nc_boolfnames(void)
		{ return(*(char **)0); }

#undef _nc_numnames
char	*const *_nc_numnames(void)
		{ return(*(char **)0); }

#undef _nc_numfnames
char	*const *_nc_numfnames(void)
		{ return(*(char **)0); }

#undef _nc_strnames
char	*const *_nc_strnames(void)
		{ return(*(char **)0); }

#undef _nc_strfnames
char	*const *_nc_strfnames(void)
		{ return(*(char **)0); }

/* ./tinfo/read_entry.c */

#include <hashed_db.h>

#undef _nc_read_termtype
int	_nc_read_termtype(
		TERMTYPE *ptr, 
		char	*buffer, 
		int	limit)
		{ return(*(int *)0); }

#undef _nc_read_file_entry
int	_nc_read_file_entry(
		const char *const filename, 
		TERMTYPE *ptr)
		{ return(*(int *)0); }

#undef _nc_read_entry
int	_nc_read_entry(
		const char *const name, 
		char	*const filename, 
		TERMTYPE *const tp)
		{ return(*(int *)0); }

/* ./tinfo/read_termcap.c */

#include <sys/types.h>

#undef _nc_read_termcap_entry
int	_nc_read_termcap_entry(
		const char *const tn, 
		TERMTYPE *const tp)
		{ return(*(int *)0); }

/* ./tinfo/setbuf.c */

#undef _nc_set_buffer
void	_nc_set_buffer(
		FILE	*ofp, 
		NCURSES_BOOL buffered)
		{ /* void */ }

/* ./tinfo/strings.c */

#undef _nc_str_init
string_desc *_nc_str_init(
		string_desc *dst, 
		char	*src, 
		size_t	len)
		{ return(*(string_desc **)0); }

#undef _nc_str_null
string_desc *_nc_str_null(
		string_desc *dst, 
		size_t	len)
		{ return(*(string_desc **)0); }

#undef _nc_str_copy
string_desc *_nc_str_copy(
		string_desc *dst, 
		string_desc *src)
		{ return(*(string_desc **)0); }

#undef _nc_safe_strcat
NCURSES_BOOL _nc_safe_strcat(
		string_desc *dst, 
		const char *src)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_safe_strcpy
NCURSES_BOOL _nc_safe_strcpy(
		string_desc *dst, 
		const char *src)
		{ return(*(NCURSES_BOOL *)0); }

/* ./trace/trace_buf.c */

#undef _nc_trace_buf
char	*_nc_trace_buf(
		int	bufnum, 
		size_t	want)
		{ return(*(char **)0); }

#undef _nc_trace_bufcat
char	*_nc_trace_bufcat(
		int	bufnum, 
		const char *value)
		{ return(*(char **)0); }

/* ./trace/trace_tries.c */

#undef _nc_trace_tries
void	_nc_trace_tries(
		TRIES	*tree)
		{ /* void */ }

/* ./base/tries.c */

#undef _nc_expand_try
char	*_nc_expand_try(
		TRIES	*tree, 
		unsigned code, 
		int	*count, 
		size_t	len)
		{ return(*(char **)0); }

#undef _nc_remove_key
int	_nc_remove_key(
		TRIES	**tree, 
		unsigned code)
		{ return(*(int *)0); }

#undef _nc_remove_string
int	_nc_remove_string(
		TRIES	**tree, 
		const char *string)
		{ return(*(int *)0); }

/* ./tinfo/trim_sgr0.c */

#undef _nc_trim_sgr0
char	*_nc_trim_sgr0(
		TERMTYPE *tp)
		{ return(*(char **)0); }

/* ./unctrl.c */

#undef _nc_unctrl
char	*_nc_unctrl(
		SCREEN	*sp, 
		chtype	ch)
		{ return(*(char **)0); }

#undef unctrl
char	*unctrl(
		chtype	ch)
		{ return(*(char **)0); }

/* ./trace/visbuf.c */

#undef _nc_visbuf2
const char *_nc_visbuf2(
		int	bufnum, 
		const char *buf)
		{ return(*(const char **)0); }

#undef _nc_visbuf
const char *_nc_visbuf(
		const char *buf)
		{ return(*(const char **)0); }

#undef _nc_visbufn
const char *_nc_visbufn(
		const char *buf, 
		int	len)
		{ return(*(const char **)0); }

#undef _nc_viscbuf2
const char *_nc_viscbuf2(
		int	bufnum, 
		const chtype *buf, 
		int	len)
		{ return(*(const char **)0); }

#undef _nc_viscbuf
const char *_nc_viscbuf(
		const chtype *buf, 
		int	len)
		{ return(*(const char **)0); }

/* ./tinfo/alloc_entry.c */

#undef _nc_init_entry
void	_nc_init_entry(
		TERMTYPE *const tp)
		{ /* void */ }

#undef _nc_copy_entry
ENTRY	*_nc_copy_entry(
		ENTRY	*oldp)
		{ return(*(ENTRY **)0); }

#undef _nc_save_str
char	*_nc_save_str(
		const char *const string)
		{ return(*(char **)0); }

#undef _nc_wrap_entry
void	_nc_wrap_entry(
		ENTRY	*const ep, 
		NCURSES_BOOL copy_strings)
		{ /* void */ }

#undef _nc_merge_entry
void	_nc_merge_entry(
		TERMTYPE *const to, 
		TERMTYPE *const from)
		{ /* void */ }

/* ./tinfo/captoinfo.c */

#undef _nc_captoinfo
char	*_nc_captoinfo(
		const char *cap, 
		const char *s, 
		int const parameterized)
		{ return(*(char **)0); }

#undef _nc_infotocap
char	*_nc_infotocap(
		const char *cap, 
		const char *str, 
		int const parameterized)
		{ return(*(char **)0); }

/* ./comp_captab.c */

#include <hashsize.h>

#undef _nc_get_table
const struct name_table_entry *_nc_get_table(
		NCURSES_BOOL termcap)
		{ return(*(const struct name_table_entry **)0); }

#undef _nc_get_hash_table
const short *_nc_get_hash_table(
		NCURSES_BOOL termcap)
		{ return(*(const short **)0); }

#undef _nc_get_alias_table
const struct alias *_nc_get_alias_table(
		NCURSES_BOOL termcap)
		{ return(*(const struct alias **)0); }

/* ./tinfo/comp_expand.c */

#undef _nc_tic_expand
char	*_nc_tic_expand(
		const char *srcp, 
		NCURSES_BOOL tic_format, 
		int	numbers)
		{ return(*(char **)0); }

/* ./tinfo/comp_hash.c */

#undef _nc_find_entry
struct name_table_entry const *_nc_find_entry(
		const char *string, 
		const short *hash_table)
		{ return(*(struct name_table_entry const **)0); }

#undef _nc_find_type_entry
struct name_table_entry const *_nc_find_type_entry(
		const char *string, 
		int	type, 
		const struct name_table_entry *table)
		{ return(*(struct name_table_entry const **)0); }

/* ./tinfo/comp_parse.c */

#undef _nc_check_termtype2
void	(*_nc_check_termtype2)(
		TERMTYPE *p1, 
		NCURSES_BOOL p2);
#undef _nc_check_termtype
void	(*_nc_check_termtype)(
		TERMTYPE *p1);

#undef _nc_entry_match
NCURSES_BOOL _nc_entry_match(
		char	*n1, 
		char	*n2)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_read_entry_source
void	_nc_read_entry_source(
		FILE	*fp, 
		char	*buf, 
		int	literal, 
		NCURSES_BOOL silent, 
		NCURSES_BOOL (*hook)(
		ENTRY	*p1))
		{ /* void */ }

#undef _nc_resolve_uses2
int	_nc_resolve_uses2(
		NCURSES_BOOL fullresolve, 
		NCURSES_BOOL literal)
		{ return(*(int *)0); }

#undef _nc_resolve_uses
int	_nc_resolve_uses(
		NCURSES_BOOL fullresolve)
		{ return(*(int *)0); }

/* ./tinfo/comp_scan.c */

#undef _nc_syntax
int	_nc_syntax;
#undef _nc_curr_file_pos
long	_nc_curr_file_pos;
#undef _nc_comment_start
long	_nc_comment_start;
#undef _nc_comment_end
long	_nc_comment_end;
#undef _nc_start_line
long	_nc_start_line;
#undef _nc_curr_token
struct token _nc_curr_token;
#undef _nc_disable_period
NCURSES_BOOL _nc_disable_period;

#undef _nc_reset_input
void	_nc_reset_input(
		FILE	*fp, 
		char	*buf)
		{ /* void */ }

#undef _nc_get_token
int	_nc_get_token(
		NCURSES_BOOL silent)
		{ return(*(int *)0); }

#undef _nc_trans_string
int	_nc_trans_string(
		char	*ptr, 
		char	*last)
		{ return(*(int *)0); }

#undef _nc_push_token
void	_nc_push_token(
		int	tokclass)
		{ /* void */ }

#undef _nc_panic_mode
void	_nc_panic_mode(
		char	ch)
		{ /* void */ }

/* ./tinfo/parse_entry.c */

#undef _nc_parse_entry
int	_nc_parse_entry(
		struct entry *entryp, 
		int	literal, 
		NCURSES_BOOL silent)
		{ return(*(int *)0); }

#undef _nc_capcmp
int	_nc_capcmp(
		const char *s, 
		const char *t)
		{ return(*(int *)0); }

typedef struct {
    const char *from;
    const char *to;
} assoc;

/* ./tinfo/write_entry.c */

#undef _nc_set_writedir
void	_nc_set_writedir(
		char	*dir)
		{ /* void */ }

#undef _nc_write_entry
void	_nc_write_entry(
		TERMTYPE *const tp)
		{ /* void */ }

#undef _nc_tic_written
int	_nc_tic_written(void)
		{ return(*(int *)0); }

/* ./base/define_key.c */

#undef define_key
int	define_key(
		const char *str, 
		int	keycode)
		{ return(*(int *)0); }

/* ./tinfo/hashed_db.c */

#undef _nc_hashed_db
void	_nc_hashed_db(void)
		{ /* void */ }

/* ./base/key_defined.c */

#undef key_defined
int	key_defined(
		const char *str)
		{ return(*(int *)0); }

/* ./base/keybound.c */

#undef keybound
char	*keybound(
		int	code, 
		int	count)
		{ return(*(char **)0); }

/* ./base/keyok.c */

#undef keyok
int	keyok(
		int	c, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/version.c */

#undef curses_version
const char *curses_version(void)
		{ return(*(const char **)0); }
